import { baseUrl, jsonHeaderContentType } from '@/config/constant/index'
import { getLocalToken, setToken } from '@/util/token'
import { queryStringUtils } from "@/util/queryStringUtils"
import type { Result } from '@/config/data/result'




// XXX 待优化为在请求前进行token校验，如果token过期则先刷新token，再进行请求
/**
 * 请求前置函数
 * @param mode 请求的模式
 */
const beforeRequest = async (mode: string) => {
  try {
    // console.log('beforeRequest', mode)

  } catch (err) {
    console.error('beforeRequest error', err)
  }
}

// 请求后置函数
const afterRequest = () => {
  // console.log('afterRequest')
}

/**
 * 普通get请求 Result风格
 * @param apiUrl 请求的api地址
 * @param query 拼接在请求路径后的参数，可选
 */
export const getResult = async <T>(
  apiUrl: string,
  query: string | number
):Promise<Result<T>> => {
  await beforeRequest('base')

  try {
    const res = await uni.request({
      url: baseUrl + apiUrl+'/'+query,
      method: 'GET',
      header: {
        "Content-Typ": jsonHeaderContentType.jsonType,
        "token": getLocalToken(),
      }
    })
    return res.data as Result<T>
  } catch (err) {
    console.error(`${apiUrl} get error`, err)
  } finally {
    afterRequest()
  }
  return null
}

/**
 * 普通get请求
 * @param apiUrl 请求的api地址
 * @param query 拼接在请求路径后的参数，可选
 */
export const get = async <T>(
  apiUrl: string,
  query: AnyObject={}
):Promise<Result<T>> => {
  await beforeRequest('base')
  try {
    const res = await uni.request({
      url: baseUrl + apiUrl+queryStringUtils(query),
      method: 'GET',
      header: {
        "Content-Type": jsonHeaderContentType.jsonType,
        "token": getLocalToken(),
      }
    })
    return res.data as Result<T>
  } catch (err) {
    console.error(`${apiUrl} get error`, err)
  } finally {
    afterRequest()
  }
  return null;
}

/**
 * 普通get请求
 * @param apiUrl 请求的api地址
 * @param query 拼接在请求路径后的参数，可选
 */
export const put = async <T>(
  apiUrl: string,
  query: AnyObject={}
):Promise<Result<T>> => {
  await beforeRequest('base')

  try {
    const res = await uni.request({
      url: baseUrl + apiUrl+queryStringUtils(query),
      method: 'PUT',
      header: {
        "Content-Type": jsonHeaderContentType.jsonType,
        "token": getLocalToken(),
      }
    })
    return res.data as Result<T>
  } catch (err) {
    console.error(`${apiUrl} get error`, err)
  } finally {
    afterRequest()
  }
  return null;
}

/**
 * 普通post请求
 * @param apiUrl 请求的api地址
 * @param data 请求的参数，可选
 */
export const post = async <T>(
  apiUrl: string,
  data: AnyObject = {}
):Promise<Result<T>> => {
  await beforeRequest('base')

  try {
    const res = await uni.request({
      url: baseUrl + apiUrl,
      method: 'POST',
      header: {
        "Content-Type": jsonHeaderContentType.jsonType,
        "token": getLocalToken(),
      },
      data,

    })
    return res.data as Result<T>
  } catch (err) {
    console.error(`${apiUrl} post error`, err)
  } finally {
    afterRequest()
  }
  return null
}






/**
 * 上传文件
 * @param apiUrl 请求的api地址
 * @param filePath 请求的参数，可选
 * @param formData 请求的其他参数，可选
 */
export const uploadFile = async (
  apiUrl: string,
  filePath: string,
  formData: AnyObject = {}
) => {
  await beforeRequest('token')

  try {
    const res = await new Promise((resolve) => {
      uni.uploadFile({
        url: baseUrl + apiUrl,
        filePath,
        header: {
          "Content-Type": jsonHeaderContentType.fileType,
          "token": getLocalToken(),
        },
        name: 'file',
        formData: {
          ...formData,
        },
        success: (successRes) => { resolve(successRes) },
        fail: (err) => { throw err },
        complete: () => { afterRequest() },
      })
    })
    return res
  } catch (err) {
    console.error(`${apiUrl} uploadFile error`, err)
  } finally {
    afterRequest()
  }
  return null
}

// const api = {
//   //登录
//   login: (code: string): Promise<Result<ResultLogin>> => {
//     return new Promise((reslove, reject) => {
//       uni.request({
//         url: baseUrl + '/attestation/login?authType=WxLogin',
//         method: 'POST',
//         data: { openid: code },
//         header: jsonHeader,
//         success: (res) => {
//           //存入令牌
//           uni.setStorage({
//             key: 'Authorization-token',
//             data: res.data.data.access_tokens,
//           })
//           reslove(res.data)
//         },
//         fail: (err) => {
//           reject(err)
//         },
//       })
//     })
//   },

//   //分页获取商品列表
//   commodityPaginatedQueries: (
//     page: Number = 1,
//     size: Number = 8,
//     commodityTypeName: string = ''
//   ): Promise<Result<ResultGoodsList[]>> => {
//     return new Promise((reslove, reject) => {
//       uni.request({
//         url:
//           baseUrl +
//           `/commodity/queryPage?page=${page}&size=${size}&commodityTypeName=${commodityTypeName}`,
//         methods: 'POST',
//         header: jsonHeader,
//         data: {
//           page: page,
//           size: size,
//           commodityTypeName: commodityTypeName,
//         },
//         success: (res) => {
//           reslove(res.data)
//         },
//         error: (err: any) => {
//           reject(err)
//         },
//       })
//     })
//   },
// }
